# 1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素,
def get_num(arraylist):
    result_list = []
    for i in range(len(arraylist)):
        if i %2 !=0:
            result_list.append(arraylist[i])
    return f"所有奇数位索引对应的元素{result_list}"


# print(get_num((55, 66, 99, 88, 77)))

# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
def istype(data):
    if isinstance(data,str):
        if len(data) > 5:
            return "是字符串对象,长度大于5"
        else:
            return "是字符串对象,长度小于5"
    elif isinstance(data,list):
        if len(data) > 5:
            return "是列表对象,长度大于5"
        else:
            return "是列表对象,长度小于5"
    elif isinstance(data,tuple):
        if len(data) > 5:
            return "是元组对象,长度大于5"
        else:
            return "是元组对象,长度小于5"
    else:
        return "传入的对象不是字符串、元组、列表"


# print(istype([1, 2, 3]))
# print(istype((1, 2, 3, 5, 5)))
# print(istype("1,2,3],5,5,5"))


# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
def count_(data):
    str_num = 0
    num = 0
    space = 0
    other = 0
    for i in data:
        if (i >= 'a' and i <="z") or (i >= 'A' and i <='Z'):
            str_num+=1
        elif i in "0123456789":
            num+=1
        elif i ==" ":
            space+=1
        else:
            other+=1
    return f"数字有{num}个,字母有{str_num}个,空格有{space}个,其他有{other}个"


# print(count_("123456 qwert /*/"))


# 4、写函数,接收两个数字参数,返回较大的那个数字
def compare(a,b):
    if a > b:
        return f"较大的数是{a}"
    elif a < b:
        return f"较大的数是{b}"
    else:
        return "两数相等"


# print(compare(5, 5))
# print(compare(6, 5))
# print(compare(5, 11))




# 5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
# 元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所有数.
def cacluate(*a):
    result_list = []
    sum1  = 0
    for i in a:
        sum1+=i
    avg = sum1 / len(a)
    for i in a:
        if i > avg:
            result_list.append(i)
    return avg,tuple(result_list)

# print(cacluate(5, 6, 7, 1, 2, 3))


# 6、编写一个函数, 接收字符串参数, 返回一个元组,
# 元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
def Receive_String(string1):
    capitalization_str = 0
    small_letter_str = 0
    for i in string1:
        if i >= 'a' and i <="z":
            small_letter_str+=1
        elif i >= 'A' and i <='Z':
            capitalization_str+=1
    return capitalization_str,small_letter_str


# print(Receive_String("abcABC"))


# 7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)
# 和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
def Return_newlist(list1,k):
    list1_a = list1[:k]
    list1_b = list1[k:]
    return list1_a[::-1]+list1_b[::-1]
# import random
# list1 = []
# for i in range(30):
#     num = random.randint(1,100)
#     list1.append(num)
# print(Return_newlist(list1, 10))


# 8、编写函数,从键盘输入参数x和n,计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
def expression_sum(x,n):
    b = x
    num=0
    sum1 = 0
    while num < n:
        sum1+=x
        x = x*10+b
        num+=1
        print(str(x),end="+")
    return f"表达式前n项的值为{sum1}"
# x=input("请输入x")
# n=input("请输入n")
#
print(expression_sum(4, 3))

# 9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
# 用户通过input输入这4个内容(支持持续输入,Q或q退出),并传递给函数
# 函数接收到这些内容,将其追加到student_msg文件中
# 重点:复习文件操作
def write_student_msg():
    while True:
        name=input("请输入姓名")
        if name == 'q' or name == 'Q':
            break
        gender=input("请输入性别")
        if gender == 'q' or gender == 'Q':
            break
        if gender =="":
            gender = "男"
        age=input("请输入年龄")
        if age == 'q' or age == 'Q':
            break
        address=input("请输入地址")
        if address == 'q' or address == 'Q':
            break
        file_lines = f"姓名：{name},性别：{gender},年龄：{age},地址：{address}"
        with open('./student_msg','a',encoding='utf-8') as f:
            f.write(file_lines+"\n")


# write_student_msg()

# 10、写函数,接收n个数字,返回这些数字的和(动态传参)
def Sum_numbers(*n):
    sum1 = 0
    for i in n:
        sum1+=i
    return f"这些数字的和(动态传参):{sum1}"

# print(Sum_numbers(1, 2, 3, 4, 5))


# 11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
def Iteration_Object(*args,**kwargs):
    return f"字符串,列表,元组,集合：{args},字典：{kwargs}"


# print(Iteration_Object("abc", (1, 2, 3), [1, 2, 3], {1, 2, 3}, 姓名="小天才"))

# 12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
def Splice_return(list1):
    str1 = ""
    for i in range(len(list1)):
        if list1[i] == list1[-1]:
            str1+=str(list1[i])
        else:
            str1+=str(list1[i]) + "_"
    return str1
# print(Splice_return([1,2,3]))




# 13、写函数,传入一个数字,返回这个数的阶乘
# 重点:累乘
#
# 示例：1x2x3....
def factorial(num):
    start = 1
    for i in range(1,num+1): # 2
        start*=i
    return f"返回这个数的阶乘{start}"
# print(factorial(4))




# 14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
def PlayingCardList():
    result_list = []
    list1=['红片',"红桃","黑片","黑桃"]
    list2 = ['J','Q','K','A']
    for i in list1:
        for j in range(2,11):
            result_list.append((i,j))
    for i in list1:
        for j in list2:
            result_list.append((i,j))
    return result_list
# print(PlayingCardList())


# 15、用代码写一个99乘法表

# 16、编写函数,求1+2+3+…N的和
def gentle(num):
    sum1 = 0
    for i in range(1,num+1):
        sum1+=i
    return f"1+2+3+…N的和：{sum1}"


# print(gentle(5))


# 17、编写一个函数,求多个数中的最大值
def maximum_numbers(*num):
    result_list = [i for i in num]
    result_list.sort(reverse=True)
    return f"最大值{result_list[0]}"


# print(maximum_numbers(77,88,99))

# 18、编写一个函数,提取指定字符串中所有的字母,然后拼接在一起产生一个新的字符串
def newstr(str1):
    new_str = ""
    for i in str1:
        if (i >= 'a' and i <= "z") or (i >= 'A' and i <= 'Z'):
            new_str+=i
    return new_str

#
# print(newstr("abc1234568qACASDQ")) # abcqACASDQ

# 19、 定义一个学生注册函数enroll(),打印学生姓名,性别,年龄,城市, 使用默认参数降低调用函数的复杂度
def enroll(姓名,性别,年龄,城市="沈阳"):
    return f"姓名：{姓名},性别：{性别},年龄：{年龄},城市：{城市}"


# print(enroll("小天才", "男", 19))


# 20、编写一个函数,接受一个字符串作为参数,并返回其中所有单词的首字母的大写形式
def capitalization_str(str1):
    return str1.capitalize()


# print(capitalization_str("abc"))

# 21、写一个函数,求多个数的平均值
def avg_num(*a):
    sum1 = 0
    for i in a:
        sum1+=i
    return f"多个数的平均值是{sum1/len(a)}"
# print(avg_num(5,6,7,8))


# 22、写一个自己的len函数,统计指定序列中元素的个数
#
# 23、找出传入的列表或元组的奇数位对应的元素,并返回一个新的列表
#
# 24、编写一个函数,接受一个字符串列表作为参数,并返回一个字符串,其中包含所有字符串首字母的大写形式
#
# 25、定义函数,有一个形参,传入的是列表,数组大小不超过 100个,
# # 数组中的每个元素值不允许超过 100,但是可以等于100,
# # 如果列表大小超过了100个截取到第100个为止,要求返回的列表格式：
#
# # 删除所有重复元素,使得每个元素只出现一次
# # 按照数字的大小,由高到低排序返回
def ReturnNewList(list1):
    if len(list1) > 100:
        list1 = list1[:100]
    new_list = []
    for i in list1:
        if list1.count(i) > 1:
            pass
        else:
            new_list.append(i)
    new_list.sort(reverse=True) # reverse=True 列表降序
    return new_list
# list1 = [i for i in range(101)]
# list1.extend([1,2,3,99])
# print(ReturnNewList(list1))





# 26、定义函数 getLength,打印用户传入的容器类型和数据长度
def getLength(container):
    if isinstance(container,list):
        return f"是列表类型，长度为：{len(container)}"
    elif isinstance(container,str):
        return f"是字符串类型，长度为：{len(container)}"
    elif isinstance(container,tuple):
        return f"是元组类型，长度为：{len(container)}"
    elif isinstance(container,set):
        return f"是集合类型，长度为：{len(container)}"
    elif isinstance(container,dict):
        return f"是字典类型，长度为：{len(container)}"
    elif isinstance(container,int):
        length = 0
        for i in str(container):
            length+=1
        return f"是整数类型，长度为：{length}"


# print(getLength("asd"))
# print(getLength([1,2,3]))
# print(getLength(("asd",1,2,3)))
# print(getLength({"asd",1,2,3}))
# print(getLength({"asd":1}))
# print(getLength(55))






# 27、定义函数 generateNum( )
# # 返回从0~9的十个数字中随机取出4个不重复的数字组成一个字符串
def generateNum():
    import random
    str1 = ""
    while True:
        num_ = random.randint(1,9)
        if num not in str1:
            str1 += num
# print(generateNum())


# 28、定义函数 moreThan(num),判断输入的数字是否大于1500
def moreThan(num):
    if num > 1500:
        return "大于"
    elif num == 1500:
        return "等于"
    else:
        return "小于"


# print(moreThan(1500))
# print(moreThan(1501))
# print(moreThan(1499))



# 29、定义函数,有两个形参,第一个形参到第二个形参的范围,所有平方数之和
#
# 示例：func_a(5,10)
# 5x5+6x6+7x7+8x8+9x9+10x10...
def func_a(a,b):
    sum1 = 0
    for i in range(a,b+1):
        sum1 += i**2
    return f"所有平方数之和{sum1}"
# print(func_a(5,10)) # 25 + 36 + 49 +64 + 81 + 100
# print(25 + 36 + 49 +64 + 81 + 100)


# 30、写函数,检查传入字典的每一个value长度,如果大于2,
# # 那么仅保留前两个长度的内容, 并将新内容返回给调用者
def check_value(dict1):
    for key,value in dict1.items():
        if len(str(value)) > 2:
            dict1[key] = str(value)[:2]
    return dict1

# print(check_value({"姓名": "小天才", "年龄": 198}))

# 31、写函数,判断用户传入的对象（字符串、列表、元组）的元素是否为空

# 32、编写自定义函数,完成一个简单的减法运算函数
#
# 33、编写自定义函数,可以输出自己的名字即可。
#
# 34、编写自定义函数：剪刀石头布
# 游戏开始,初始状态下用户和电脑都有 100 分,赢一局+10 分,输一局-10 分。
#
# 当用户为 0 分时,游戏结束,提示游戏结束,比赛输了
#
# 当用户为 200 分时,游戏结束,提示游戏结束,赢得比赛、每轮比赛都输出当前的分数
#
# 1 代表剪刀 2 代表石头 3 代表布



# 35、编写一个函数,接受一个字符串作为参数,并返回该字符串的逆序字符串
def ReverseString(str1):
    return str1[::-1]


# 36、编写一个函数,接受一个数字列表作为参数,并返回其中所有偶数的列表
def EvenNumberedList(list1):
    EvenNumberedList1 = []
    for i in list1:
        if i%2==0:
            EvenNumberedList1.append(i)
    return EvenNumberedList1

# 37、编写一个函数,接受一个字符串列表作为参数,并返回其中最长的字符串。
def LongestString(strlist):
    str1 = ""
    for i in strlist:
        if len(i) > len(str1):
            str1 = i
    return f"最长的字符串是{str1}"


# print(LongestString(['adb', "asd", "ad", "asdqwe"]))


# 38、编写一个函数,接受一个数字列表作为参数,并返回其中所有数字的平方的总和
#
# 39、编写一个函数,接受一个整数作为参数,并返回其阶乘